home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / FAQSYS18.ZIP / FAQS.DAT / 86.SET < prev    next >
Text File  |  1996-01-09  |  28KB  |  436 lines
  1. How to Read the Instruction Set Chart
  2.  
  3. In order to use the chart, you need to learn the meanings of the
  4. specifiers (each given by 2 lower case letters) that follow most
  5. of the instruction mnemonics.  Each specifier indicates the type
  6. of operand (register byte, immediate word, etc.) that follows
  7. the mnemonic to produce the given opcodes.
  8.  
  9.  
  10. "c"  means the operand is a code label, pointing to a part of the
  11.     program to be jumped to or called. Operands will also accept a
  12.     constant offset in this place (or a constant segment-offset
  13.     pair in the case of "cd").  "cb" is a label within about 128
  14.     bytes (in either direction) of the current location.  "cw" is
  15.     a label within the same code segment as this program; "cd" is
  16.     a pair of constants separated by a colon-- the segment value
  17.     to the left of the colon, and the offset to the right.  Note
  18.     that in both the cb and cw cases, the object code generated
  19.     is the offset from the location following the current
  20.     instruction, not the absolute location of the label operand.
  21.     In some assemblers (most notably for the Z-80 processor) you
  22.     have to code this offset explicitly by putting "$-" before
  23.     every relative jump operand in your source code.
  24.  
  25. "e"  means the operand is an Effective Address.  The concept of
  26.     an Effective Address is central to the 86 machine
  27.     architecture, and thus to 86 assembly language programming.
  28.     It is described in detail at the start of this chapter.  We
  29.     summarize here by saying that an Effective Address is either
  30.     a general purpose register, a memory variable, or an indexed
  31.     memory quantity.  For example, the instruction "ADD rb,eb"
  32.     includes the instructions: ADD AL,BL, and ADD CH,BYTEVAR, and
  33.     ADD DL,B[BX+17].
  34.  
  35. "i"  means the operand is an immediate constant, provided as part
  36.     of the instruction itself.  "ib" is a byte-sized constant;
  37.     "iw" is a constant occupying a full 16-bit word.  The operand
  38.     can also be a label, defined with a colon.  In that case, the
  39.     immediate constant which is the location of the label is
  40.     used.  Examples:  "MOV rw,iw" includes the instructions: MOV
  41.     AX,17, or MOV SI,VAR_ARRAY, where "VAR_ARRAY:" appears
  42.     somewhere in the program, defined with a colon.  NOTE that if
  43.     VAR_ARRAY were defined without a colon, e.g., "VAR_ARRAY DW
  44.     1,2,3", then "MOV SI,VAR_ARRAY" would be a "MOV rw,ew" NOT a
  45.     "MOV rw,iw".  The MOV would move the contents of memory at
  46.     VAR_ARRAY (in this case 1) into SI, instead of the location
  47.     of the memory. To load the location, you can code "MOV
  48.     SI,OFFSET VAR_ARRAY".
  49.  
  50. "m"  means a memory variable or an indexed memory quantity; i.e.,
  51.     any Effective Address EXCEPT a register.
  52.  
  53. "r"  means the operand is a general purpose register.  The 8 "rb"
  54.     registers are AL,BL,CL,DL,AH,BH,CH,DH; the 8 "rw" registers
  55.     are AX,BX,CX,DX,SI,DI,BP,SP.
  56.  
  57.  
  58. WARNING: Instruction forms marked with "*" by the mnemonic are
  59. part of the extended 186/286/NEC instruction set. Instructions
  60. marked with "#" are unique to the NEC processors.  These
  61. instructions will NOT work on the 8088 of the IBM-PC; nor will
  62. they work on the 8086; nor will the NEC instructions work on the
  63. 186 or 286. If you wish your programs to run on all PC's, do not
  64. use these instructions!
  65.  
  66.  
  67. Opcodes     Instruction    Description
  68.  
  69. 37          AAA            ASCII adjust AL (carry into AH) after addition
  70. D5 0A       AAD            ASCII adjust before division (AX = 10*AH + AL)
  71. D4 0A       AAM            ASCII adjust after multiply (AL/10: AH=Quo AL=Rem)
  72. 3F          AAS            ASCII adjust AL (borrow from AH) after subtraction
  73. 14 ib       ADC AL,ib      Add with carry immediate byte into AL
  74. 15 iw       ADC AX,iw      Add with carry immediate word into AX
  75. 80 /2 ib    ADC eb,ib      Add with carry immediate byte into EA byte
  76. 10 /r       ADC eb,rb      Add with carry byte register into EA byte
  77. 83 /2 ib    ADC ew,ib      Add with carry immediate byte into EA word
  78. 81 /2 iw    ADC ew,iw      Add with carry immediate word into EA word
  79. 11 /r       ADC ew,rw      Add with carry word register into EA word
  80. 12 /r       ADC rb,eb      Add with carry EA byte into byte register
  81. 13 /r       ADC rw,ew      Add with carry EA word into word register
  82. 04 ib       ADD AL,ib      Add immediate byte into AL
  83. 05 iw       ADD AX,iw      Add immediate word into AX
  84. 80 /0 ib    ADD eb,ib      Add immediate byte into EA byte
  85. 00 /r       ADD eb,rb      Add byte register into EA byte
  86. 83 /0 ib    ADD ew,ib      Add immediate byte into EA word
  87. 81 /0 iw    ADD ew,iw      Add immediate word into EA word
  88. 01 /r       ADD ew,rw      Add word register into EA word
  89. 02 /r       ADD rb,eb      Add EA byte into byte register
  90. 03 /r       ADD rw,ew      Add EA word into word register
  91. 0F 20      #ADD4S          Add CL nibbles BCD from DS:SI into ES:DI (CL even,NZ)
  92. 24 ib       AND AL,ib      Logical-AND immediate byte into AL
  93. 25 iw       AND AX,iw      Logical-AND immediate word into AX
  94. 80 /4 ib    AND eb,ib      Logical-AND immediate byte into EA byte
  95. 20 /r       AND eb,rb      Logical-AND byte register into EA byte
  96. 83 /4 ib    AND ew,ib      Logical-AND immediate byte into EA word
  97. 81 /4 iw    AND ew,iw      Logical-AND immediate word into EA word
  98. 21 /r       AND ew,rw      Logical-AND word register into EA word
  99. 22 /r       AND rb,eb      Logical-AND EA byte into byte register
  100. 23 /r       AND rw,ew      Logical-AND EA word into word register
  101. 63 /r      *ARPL ew,rw     Adjust RPL of EA word not smaller than RPL of rw
  102. 62 /r      *BOUND rw,md    INT 5 if rw not between [md] and [md+2] inclusive
  103. 9A cd       CALL cd        Call far segment, immediate 4-byte address
  104. E8 cw       CALL cw        Call near, offset relative to next instruction
  105. FF /3       CALL ed        Call far segment, address at EA doubleword
  106. FF /2       CALL ew        Call near, offset absolute at EA word
  107. 0F FF ib   #CALL80 ib      Call 8080-emulation code at INT number ib
  108. 98          CBW            Convert byte into word (AH = top bit of AL)
  109. F8          CLC            Clear carry flag
  110. FC          CLD            Clear direction flag so SI and DI will increment
  111. FA          CLI            Clear interrupt enable flag; interrupts disabled
  112. 0F 12/0    #CLRBIT eb,CL   Clear bit CL of eb
  113. 0F 13/0    #CLRBIT ew,CL   Clear bit CL of ew
  114. 0F 1A/0 ib #CLRBIT eb,ib   Clear bit ib of eb
  115. 0F 1B/0 ib #CLRBIT ew,ib   Clear bit ib of ew
  116. 0F 06      *CLTS           Clear task switched flag
  117. F5          CMC            Complement carry flag
  118. 3C ib       CMP AL,ib      Subtract immediate byte from AL for flags only
  119. 3D iw       CMP AX,iw      Subtract immediate word from AX for flags only
  120. 80 /7 ib    CMP eb,ib      Subtract immediate byte from EA byte for flags only
  121. 38 /r       CMP eb,rb      Subtract byte register from EA byte for flags only
  122. 83 /7 ib    CMP ew,ib      Subtract immediate byte from EA word for flags only
  123. 81 /7 iw    CMP ew,iw      Subtract immediate word from EA word for flags only
  124. 39 /r       CMP ew,rw      Subtract word register from EA word for flags only
  125. 3A /r       CMP rb,eb      Subtract EA byte from byte register for flags only
  126. 3B /r       CMP rw,ew      Subtract EA word from word register for flags only
  127. 0F 26      #CMP4S          Compare CL nibbles CD at DS:SI from ES:DI (CL even,NZ)
  128. A6          CMPS mb,mb     Compare bytes ES:[DI] from [SI], advance SI and DI
  129. A7          CMPS mw,mw     Compare words ES:[DI] from [SI], advance SI and DI
  130. A6          CMPSB          Compare bytes ES:[DI] from DS:[SI], advance SI and DI
  131. A7          CMPSW          Compare words ES:[DI] from DS:[SI], advance SI and DI
  132. 99          CWD            Convert word to doubleword (DX = top bit of AX)
  133. 27          DAA            Decimal adjust AL after addition
  134. 2F          DAS            Decimal adjust AL after subtraction
  135. FE /1       DEC eb         Decrement EA byte by 1
  136. FF /1       DEC ew         Decrement EA word by 1
  137. 48+rw       DEC rw         Decrement word register by 1
  138. F6 /6       DIV eb         Unsigned divide AX by EA byte (AL=Quo AH=Rem)
  139. F7 /6       DIV ew         Unsigned divide DXAX by EA word (AX=Quo DX=Rem)
  140. C8 iw 00   *ENTER iw,0     Make stack frame, iw bytes local storage, 0 levels
  141. C8 iw 01   *ENTER iw,1     Make stack frame, iw bytes local storage, 1 level
  142. C8 iw ib   *ENTER iw,ib    Make stack frame, iw bytes local storage, ib levels
  143. F4          HLT            Halt
  144. F6 /7       IDIV eb        Signed divide AX by EA byte (AL=Quo AH=Rem)
  145. F7 /7       IDIV ew        Signed divide DXAX by EA word (AX=Quo DX=Rem)
  146. F6 /5       IMUL eb        Signed multiply (AX = AL * EA byte)
  147. F7 /5       IMUL ew        Signed multiply (DXAX = AX * EA word)
  148. 6B /r ib   *IMUL rw,ib     Signed multiply immediate byte into word register
  149. 69 /r iw   *IMUL rw,iw     Signed multiply immediate word into word register
  150. 69 /r iw   *IMUL rw,ew,iw  Signed multiply (rw = EA word * immediate word)
  151. 6B /r ib   *IMUL rw,ew,ib  Signed multiply (rw = EA word * immediate byte)
  152. E4 ib       IN AL,ib       Input byte from immediate port into AL
  153. EC          IN AL,DX       Input byte from port DX into AL
  154. E5 ib       IN AX,ib       Input word from immediate port into AX
  155. ED          IN AX,DX       Input word from port DX into AX
  156. FE /0       INC eb         Increment EA byte by 1
  157. FF /0       INC ew         Increment EA word by 1
  158. 40+rw       INC rw         Increment word register by 1
  159. 6C         *INS eb,DX      Input byte from port DX into [DI]
  160. 6D         *INS ew,DX      Input word from port DX into [DI]
  161. 6C         *INSB           Input byte from port DX into ES:[DI]
  162. 6D         *INSW           Input word from port DX into ES:[DI]
  163. CC          INT 3          Interrupt 3 (trap to debugger) (far call, with flags
  164. CD ib       INT ib         Interrupt numbered by immediate byte     pushed first)
  165. CE          INTO           Interrupt 4 if overflow flag is 1
  166. CF          IRET           Interrupt return (far return and pop flags)
  167. 77 cb       JA cb          Jump short if above (CF=0 and ZF=0)    above=UNSIGNED
  168. 73 cb       JAE cb         Jump short if above or equal (CF=0)
  169. 72 cb       JB cb          Jump short if below (CF=1)             below=UNSIGNED
  170. 76 cb       JBE cb         Jump short if below or equal (CF=1 or ZF=1)
  171. 72 cb       JC cb          Jump short if carry (CF=1)
  172. E3 cb       JCXZ cb        Jump short if CX register is zero
  173. 74 cb       JE cb          Jump short if equal (ZF=1)
  174. 7F cb       JG cb          Jump short if greater (ZF=0 and SF=OF)  greater=SIGNED
  175. 7D cb       JGE cb         Jump short if greater or equal (SF=OF)
  176. 7C cb       JL cb          Jump short if less (SF/=OF)                less=SIGNED
  177. 7E cb       JLE cb         Jump short if less or equal (ZF=1 or SF/=OF)
  178. EB cb       JMP cb         Jump short (signed byte relative to next instruction)
  179. EA cd       JMP cd         Jump far (4-byte immediate address)
  180. E9 cw       JMP cw         Jump near (word offset relative to next instruction)
  181. FF /4       JMP ew         Jump near to EA word (absolute offset)
  182. FF /5       JMP md         Jump far (4-byte address in memory doubleword)
  183. 76 cb       JNA cb         Jump short if not above (CF=1 or ZF=1)
  184. 72 cb       JNAE cb        Jump short if not above or equal (CF=1)
  185. 73 cb       JNB cb         Jump short if not below (CF=0)
  186. 77 cb       JNBE cb        Jump short if not below or equal (CF=0 and ZF=0)
  187. 73 cb       JNC cb         Jump short if not carry (CF=0)
  188. 75 cb       JNE cb         Jump short if not equal (ZF=0)
  189. 7E cb       JNG cb         Jump short if not greater (ZF=1 or SF/=OF)
  190. 7C cb       JNGE cb        Jump short if not greater or equal (SF/=OF)
  191. 7D cb       JNL cb         Jump short if not less (SF=OF)
  192. 7F cb       JNLE cb        Jump short if not less or equal (ZF=0 and SF=OF)
  193. 71 cb       JNO cb         Jump short if not overflow (OF=0)
  194. 7B cb       JNP cb         Jump short if not parity (PF=0)
  195. 79 cb       JNS cb         Jump short if not sign (SF=0)
  196. 75 cb       JNZ cb         Jump short if not zero (ZF=0)
  197. 70 cb       JO cb          Jump short if overflow (OF=1)
  198. 7A cb       JP cb          Jump short if parity (PF=1)
  199. 7A cb       JPE cb         Jump short if parity even (PF=1)
  200. 7B cb       JPO cb         Jump short if parity odd (PF=0)
  201. 78 cb       JS cb          Jump short if sign (SF=1)
  202. 74 cb       JZ cb          Jump short if zero (ZF=1)
  203. 9F          LAHF           Load: AH = flags  SF ZF xx AF xx PF xx CF
  204. 0F 02 /r   *LAR rw,ew      Load: high(rw) = Access Rights byte, selector ew
  205. C5 /r       LDS rw,ed      Load EA doubleword into DS and word register
  206. 8D /r       LEA rw,m       Calculate EA offset given by m, place in rw
  207. C9         *LEAVE          Set SP to BP, then POP BP (reverses previous ENTER)
  208. C4 /r       LES rw,ed      Load EA doubleword into ES and word register
  209. 0F 01 /2   *LGDT m         Load 6 bytes at m into Global Descriptor Table reg
  210. 0F 01 /3   *LIDT m         Load 6 bytes at m into Interrupt Descriptor Table reg
  211. 0F 00 /2   *LLDT ew        Load selector ew into Local Descriptor Table reg
  212. 0F 01 /6   *LMSW ew        Load EA word into Machine Status Word
  213. F0          LOCK (prefix)  Assert BUSLOCK signal for the next instruction
  214. 0F 33/r    #LODBITS rb,rb  Load AX with DS:SI,bit rb (incr. SI,rb), rb+1 bits
  215. 0F 3B/0 ib #LODBITS rb,ib  Load AX with DS:SI,bit rb (incr. SI,rb), ib+1 bits
  216. AC          LODS mb        Load byte [SI] into AL, advance SI
  217. AD          LODS mw        Load word [SI] into AX, advance SI
  218. AC          LODSB          Load byte [SI] into AL, advance SI
  219. AD          LODSW          Load word [SI] into AX, advance SI
  220. E2 cb       LOOP cb        noflags DEC CX; jump short if CX/=0
  221. E1 cb       LOOPE cb       noflags DEC CX; jump short if CX/=0 and equal (ZF=1)
  222. E0 cb       LOOPNE cb      noflags DEC CX; jump short if CX/=0 and not equal
  223. E0 cb       LOOPNZ cb      noflags DEC CX; jump short if CX/=0 and ZF=0
  224. E1 cb       LOOPZ cb       noflags DEC CX; jump short if CX/=0 and zero (ZF=1)
  225. 0F 03 /r   *LSL rw,ew      Load: rw = Segment Limit, selector ew
  226. 0F 00 /3   *LTR ew         Load EA word into Task Register
  227. A0 iw       MOV AL,xb      Move byte variable (offset iw) into AL
  228. A1 iw       MOV AX,xw      Move word variable (offset iw) into AX
  229. 8E /3       MOV DS,mw      Move memory word into DS
  230. 8E /3       MOV DS,rw      Move word register into DS
  231. C6 /0 ib    MOV eb,ib      Move immediate byte into EA byte
  232. 88 /r       MOV eb,rb      Move byte register into EA byte
  233. 8E /0       MOV ES,mw      Move memory word into ES
  234. 8E /0       MOV ES,rw      Move word register into ES
  235. 8C /1       MOV ew,CS      Move CS into EA word
  236. 8C /3       MOV ew,DS      Move DS into EA word
  237. C7 /0 iw    MOV ew,iw      Move immediate word into EA word
  238. 8C /0       MOV ew,ES      Move ES into EA word
  239. 89 /r       MOV ew,rw      Move word register into EA word
  240. 8C /2       MOV ew,SS      Move SS into EA word
  241. B0+rb ib    MOV rb,ib      Move immediate byte into byte register
  242. 8A /r       MOV rb,eb      Move EA byte into byte register
  243. B8+rw iw    MOV rw,iw      Move immediate word into word register
  244. 8B /r       MOV rw,ew      Move EA word into word register
  245. 8E /2       MOV SS,mw      Move memory word into SS
  246. 8E /2       MOV SS,rw      Move word register into SS
  247. A2 iw       MOV xb,AL      Move AL into byte variable (offset iw)
  248. A3 iw       MOV xw,AX      Move AX into word register (offset iw)
  249. A4          MOVS mb,mb     Move byte [SI] to ES:[DI], advance SI and DI
  250. A5          MOVS mw,mw     Move word [SI] to ES:[DI], advance SI and DI
  251. A4          MOVSB          Move byte DS:[SI] to ES:[DI], advance SI and DI
  252. A5          MOVSW          Move word DS:[SI] to ES:[DI], advance SI and DI
  253. F6 /4       MUL eb         Unsigned multiply (AX = AL * EA byte)
  254. F7 /4       MUL ew         Unsigned multiply (DXAX = AX * EA word)
  255. F6 /3       NEG eb         Two's complement negate EA byte
  256. F7 /3       NEG ew         Two's complement negate EA word
  257. 90          NOP            No Operation
  258. F6 /2       NOT eb         Reverse each bit of EA byte
  259. F7 /2       NOT ew         Reverse each bit of EA word
  260. 0F 16/0    #NOTBIT eb,CL   Complement bit CL of eb
  261. 0F 17/0    #NOTBIT ew,CL   Complement bit CL of ew
  262. 0F 1E/0 ib #NOTBIT eb,ib   Complement bit ib of eb
  263. 0F 1F/0 ib #NOTBIT ew,ib   Complement bit ib of ew
  264. 0C ib       OR AL,ib       Logical-OR immediate byte into AL
  265. 0D iw       OR AX,iw       Logical-OR immediate word into AX
  266. 80 /1 ib    OR eb,ib       Logical-OR immediate byte into EA byte
  267. 08 /r       OR eb,rb       Logical-OR byte register into EA byte
  268. 83 /1 ib    OR ew,ib       Logical-OR immediate byte into EA word
  269. 81 /1 iw    OR ew,iw       Logical-OR immediate word into EA word
  270. 09 /r       OR ew,rw       Logical-OR word register into EA word
  271. 0A /r       OR rb,eb       Logical-OR EA byte into byte register
  272. 0B /r       OR rw,ew       Logical-OR EA word into word register
  273. E6 ib       OUT ib,AL      Output byte AL to immediate port number ib
  274. E7 ib       OUT ib,AX      Output word AX to immediate port number ib
  275. EE          OUT DX,AL      Output byte AL to port number DX
  276. EF          OUT DX,AX      Output word AX to port number DX
  277. 6E         *OUTS DX,eb     Output byte [SI] to port number DX, advance SI
  278. 6F         *OUTS DX,ew     Output word [SI] to port number DX, advance SI
  279. 6E         *OUTSB          Output byte DS:[SI] to port number DX, advance SI
  280. 6F         *OUTSW          Output word DS:[SI] to port number DX, advance SI
  281. 1F          POP DS         Set DS to top of stack, increment SP by 2
  282. 07          POP ES         Set ES to top of stack, increment SP by 2
  283. 8F /0       POP mw         Set memory word to top of stack, increment SP by 2
  284. 58+rw       POP rw         Set word register to top of stack, increment SP by 2
  285. 17          POP SS         Set SS to top of stack, increment SP by 2
  286. 61         *POPA           Pop DI,SI,BP,SP,BX,DX,CX,AX (SP value is ignored)
  287. 9D          POPF           Set flags register to top of stack, increment SP by 2
  288. 0E          PUSH CS        Set [SP-2] to CS, then decrement SP by 2
  289. 1E          PUSH DS        Set [SP-2] to DS, then decrement SP by 2
  290. 06          PUSH ES        Set [SP-2] to ES, then decrement SP by 2
  291. 6A ib      *PUSH ib        Push sign-extended immediate byte
  292. 68 iw      *PUSH iw        Set [SP-2] to immediate word, then decrement SP by 2
  293. FF /6       PUSH mw        Set [SP-2] to memory word, then decrement SP by 2
  294. 50+rw       PUSH rw        Set [SP-2] to word register, then decrement SP by 2
  295. 16          PUSH SS        Set [SP-2] to SS, then decrement SP by 2
  296. 60         *PUSHA          Push AX,CX,DX,BX,original SP,BP,SI,DI
  297. 9C          PUSHF          Set [SP-2] to flags register, then decrement SP by 2
  298. D0 /2       RCL eb,1       Rotate 9-bit quantity (CF, EA byte) left once
  299. D2 /2       RCL eb,CL      Rotate 9-bit quantity (CF, EA byte) left CL times
  300. C0 /2 ib   *RCL eb,ib      Rotate 9-bit quantity (CF, EA byte) left ib times
  301. D1 /2       RCL ew,1       Rotate 17-bit quantity (CF, EA word) left once
  302. D3 /2       RCL ew,CL      Rotate 17-bit quantity (CF, EA word) left CL times
  303. C1 /2 ib   *RCL ew,ib      Rotate 17-bit quantity (CF, EA word) left ib times
  304. D0 /3       RCR eb,1       Rotate 9-bit quantity (CF, EA byte) right once
  305. D2 /3       RCR eb,CL      Rotate 9-bit quantity (CF, EA byte) right CL times
  306. C0 /3 ib   *RCR eb,ib      Rotate 9-bit quantity (CF, EA byte) right ib times
  307. D1 /3       RCR ew,1       Rotate 17-bit quantity (CF, EA word) right once
  308. D3 /3       RCR ew,CL      Rotate 17-bit quantity (CF, EA word) right CL times
  309. C1 /3 ib   *RCR ew,ib      Rotate 17-bit quantity (CF, EA word) right ib times
  310. F3          REP (prefix)   Repeat following MOVS,LODS,STOS,INS, or OUTS CX times
  311. 65         #REPC (prefix)  Repeat following CMPS or SCAS CX times or until CF=0
  312. F3          REPE (prefix)  Repeat following CMPS or SCAS CX times or until ZF=0
  313. 64         #REPNC (prfix)  Repeat following CMPS or SCAS CX times or until CF=1
  314. F2          REPNE (prfix)  Repeat following CMPS or SCAS CX times or until ZF=1
  315. F2          REPNZ (prfix)  Repeat following CMPS or SCAS CX times or until ZF=1
  316. F3          REPZ (prefix)  Repeat following CMPS or SCAS CX times or until ZF=0
  317. CB          RETF           Return to far caller (pop offset, then seg)
  318. C3          RET            Return to near caller (pop offset only)
  319. CA iw       RETF iw        RET (far), pop offset, seg, iw bytes
  320. C2 iw       RET iw         RET (near), pop offset, iw bytes pushed before Call
  321. D0 /0       ROL eb,1       Rotate 8-bit EA byte left once
  322. D2 /0       ROL eb,CL      Rotate 8-bit EA byte left CL times
  323. C0 /0 ib   *ROL eb,ib      Rotate 8-bit EA byte left ib times
  324. D1 /0       ROL ew,1       Rotate 16-bit EA word left once
  325. D3 /0       ROL ew,CL      Rotate 16-bit EA word left CL times
  326. C1 /0 ib   *ROL ew,ib      Rotate 16-bit EA word left ib times
  327. 0F 28/0    #ROL4 eb        Rotate nibbles: Heb=Leb   HAL,Leb=LAL  LAL=Heb
  328. D0 /1       ROR eb,1       Rotate 8-bit EA byte right once
  329. D2 /1       ROR eb,CL      Rotate 8-bit EA byte right CL times
  330. C0 /1 ib   *ROR eb,ib      Rotate 8-bit EA byte right ib times
  331. D1 /1       ROR ew,1       Rotate 16-bit EA word right once
  332. D3 /1       ROR ew,CL      Rotate 16-bit EA word right CL times
  333. C1 /1 ib   *ROR ew,ib      Rotate 16-bit EA word right ib times
  334. 0F 2A/0    #ROR4 eb        Rotate nibbles: Leb=Heb   Heb=LAL  AL=eb
  335. 9E          SAHF           Store AH into flags  SF ZF xx AF xx PF xx CF
  336. D0 /4       SAL eb,1       Multiply EA byte by 2, once
  337. D2 /4       SAL eb,CL      Multiply EA byte by 2, CL times
  338. C0 /4 ib   *SAL eb,ib      Multiply EA byte by 2, ib times
  339. D1 /4       SAL ew,1       Multiply EA word by 2, once
  340. D3 /4       SAL ew,CL      Multiply EA word by 2, CL times
  341. C1 /4 ib   *SAL ew,ib      Multiply EA word by 2, ib times
  342. D0 /7       SAR eb,1       Signed divide EA byte by 2, once
  343. D2 /7       SAR eb,CL      Signed divide EA byte by 2, CL times
  344. C0 /7 ib   *SAR eb,ib      Signed divide EA byte by 2, ib times
  345. D1 /7       SAR ew,1       Signed divide EA word by 2, once
  346. D3 /7       SAR ew,CL      Signed divide EA word by 2, CL times
  347. C1 /7 ib   *SAR ew,ib      Signed divide EA word by 2, ib times
  348. 1C ib       SBB AL,ib      Subtract with borrow immediate byte from AL
  349. 1D iw       SBB AX,iw      Subtract with borrow immediate word from AX
  350. 80 /3 ib    SBB eb,ib      Subtract with borrow immediate byte from EA byte
  351. 18 /r       SBB eb,rb      Subtract with borrow byte register from EA byte
  352. 83 /3 ib    SBB ew,ib      Subtract with borrow immediate byte from EA word
  353. 81 /3 iw    SBB ew,iw      Subtract with borrow immediate word from EA word
  354. 19 /r       SBB ew,rw      Subtract with borrow word register from EA word
  355. 1A /r       SBB rb,eb      Subtract with borrow EA byte from byte register
  356. 1B /r       SBB rw,ew      Subtract with borrow EA word from word register
  357. AE          SCAS mb        Compare bytes AL - ES:[DI], advance DI
  358. AF          SCAS mw        Compare words AL - ES:[DI], advance DI
  359. AE          SCASB          Compare bytes AX - ES:[DI], advance DI
  360. AF          SCASW          Compare words AX - ES:[DI], advance DI
  361. 0F 14/0    #SETBIT eb,CL   Set bit CL of eb
  362. 0F 15/0    #SETBIT ew,CL   Set bit CL of ew
  363. 0F 1C/0 ib #SETBIT eb,ib   Set bit ib of eb
  364. 0F 1D/0 ib #SETBIT ew,ib   Set bit ib of ew
  365. 0F 01 /0   *SGDT m         Store 6-byte Global Descriptor Table register to M
  366. D0 /4       SHL eb,1       Multiply EA byte by 2, once
  367. D2 /4       SHL eb,CL      Multiply EA byte by 2, CL times
  368. C0 /4 ib   *SHL eb,ib      Multiply EA byte by 2, ib times
  369. D1 /4       SHL ew,1       Multiply EA word by 2, once
  370. D3 /4       SHL ew,CL      Multiply EA word by 2, CL times
  371. C1 /4 ib   *SHL ew,ib      Multiply EA word by 2, ib times
  372. D0 /5       SHR eb,1       Unsigned divide EA byte by 2, once
  373. D2 /5       SHR eb,CL      Unsigned divide EA byte by 2, CL times
  374. C0 /5 ib   *SHR eb,ib      Unsigned divide EA byte by 2, ib times
  375. D1 /5       SHR ew,1       Unsigned divide EA word by 2, once
  376. D3 /5       SHR ew,CL      Unsigned divide EA word by 2, CL times
  377. C1 /5 ib   *SHR ew,ib      Unsigned divide EA word by 2, ib times
  378. 0F 01 /1   *SIDT m         Store 6-byte Interrupt Descriptor Table register to M
  379. 0F 00 /0   *SLDT ew        Store Local Descriptor Table register to EA word
  380. 0F 01 /4   *SMSW ew        Store Machine Status Word to EA word
  381. F9          STC            Set carry flag
  382. FD          STD            Set direction flag so SI and DI will decrement
  383. FB          STI            Set interrupt enable flag, interrupts enabled
  384. 0F 31/r    #STOBITS rb,rb  Store AX to ES:DI,bit rb (incr. DI,rb), rb+1 bits
  385. 0F 39/0 ib #STOBITS rb,ib  Store AX to ES:DI,bit rb (incr. DI,rb), ib+1 bits
  386. AA          STOS mb        Store AL to byte [DI], advance DI
  387. AB          STOS mw        Store AX to word [DI], advance DI
  388. AA          STOSB          Store AL to byte ES:[DI], advance DI
  389. AB          STOSW          Store AX to word ES:[DI], advance DI
  390. 0F 00 /1   *STR ew         Store Task Register to EA word
  391. 2C ib       SUB AL,ib      Subtract immediate byte from AL
  392. 2D iw       SUB AX,iw      Subtract immediate word from AX
  393. 80 /5 ib    SUB eb,ib      Subtract immediate byte from EA byte
  394. 28 /r       SUB eb,rb      Subtract byte register from EA byte
  395. 83 /5 ib    SUB ew,ib      Subtract immediate byte from EA word
  396. 81 /5 iw    SUB ew,iw      Subtract immediate word from EA word
  397. 29 /r       SUB ew,rw      Subtract word register from EA word
  398. 2A /r       SUB rb,eb      Subtract EA byte from byte register
  399. 2B /r       SUB rw,ew      Subtract EA word from word register
  400. 0F 22      #SUB4S          Sub CL nibbles BCD at DS:SI from ES:DI (CL even,NZ)
  401. A8 ib       TEST AL,ib     AND immediate byte into AL for flags only
  402. A9 iw       TEST AX,iw     AND immediate word into AX for flags only
  403. F6 /0 ib    TEST eb,ib     AND immediate byte into EA byte for flags only
  404. 84 /r       TEST eb,rb     AND byte register into EA byte for flags only
  405. F7 /0 iw    TEST ew,iw     AND immediate word into EA word for flags only
  406. 85 /r       TEST ew,rw     AND word register into EA word for flags only
  407. 84 /r       TEST rb,eb     AND EA byte into byte register for flags only
  408. 85 /r       TEST rw,ew     AND EA word into word register for flags only
  409. 0F 10/0    #TESTBIT eb,CL  Test bit CL of eb, set Z flag
  410. 0F 11/0    #TESTBIT ew,CL  Test bit CL of ew, set Z flag
  411. 0F 18/0 ib #TESTBIT eb,ib  Test bit ib of eb, set Z flag
  412. 0F 19/0 ib #TESTBIT ew,ib  Test bit ib of ew, set Z flag
  413. 9B          WAIT           Wait until BUSY pin is inactive (HIGH)
  414. 0F 00 /4   *VERR ew        Set ZF=1 if segment can be read, selector ew
  415. 0F 00 /5   *VERW ew        Set ZF=1 if segment can be written to, selector ew
  416. 9r          XCHG AX,rw     Exchange word register with AX
  417. 86 /r       XCHG eb,rb     Exchange byte register with EA byte
  418. 87 /r       XCHG ew,rw     Exchange word register with EA word
  419. 86 /r       XCHG rb,eb     Exchange EA byte with byte register
  420. 9r          XCHG rw,AX     Exchange  with word register
  421. 87 /r       XCHG rw,ew     Exchange EA word with word register
  422. D7          XLAT mb        Set AL to memory byte [BX + unsigned AL]
  423. D7          XLATB          Set AL to memory byte DS:[BX + unsigned AL]
  424. 34 ib       XOR AL,ib      Exclusive-OR immediate byte into AL
  425. 35 iw       XOR AX,iw      Exclusive-OR immediate word into AX
  426. 80 /6 ib    XOR eb,ib      Exclusive-OR immediate byte into EA byte
  427. 30 /r       XOR eb,rb      Exclusive-OR byte register into EA byte
  428. 83 /6 ib    XOR ew,ib      Exclusive-OR immediate byte into EA word
  429. 81 /6 iw    XOR ew,iw      Exclusive-OR immediate word into EA word
  430. 31 /r       XOR ew,rw      Exclusive-OR word register into EA word
  431. 32 /r       XOR rb,eb      Exclusive-OR EA byte into byte register
  432. 33 /r       XOR rw,ew      Exclusive-OR EA word into word register
  433.  
  434. *  Starred forms will not execute on 8086/8088!  See note at top of chart.
  435. #  These instructions work only on NEC chips!  See note at top of chart.
  436.